{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 没有调到98%，根据上课学员及老师交流后更新，之前用卷积达到了\n",
    "\n",
    "1. 设置隐层为300个神经元\n",
    "2. 学习率为0.9\n",
    "3. 调整了batch size跟training step\n",
    "4. 加入l2 loss\n",
    "5. 微调初始化参数W_1 W_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 首先导入一些用到的库。\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-10a22b6522ad>:2: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./mnist_dataset/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./mnist_dataset/train-labels-idx1-ubyte.gz\n",
      "Extracting ./mnist_dataset/t10k-images-idx3-ubyte.gz\n",
      "Extracting ./mnist_dataset/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000,)\n",
      "(5000, 784)\n",
      "(5000,)\n",
      "(10000, 784)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "# 先来看看数据长什么样子\n",
    "mnist = input_data.read_data_sets(\"./mnist_dataset\")\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4, idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(mnist.train.labels[idx]))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个float类型的变量用于设置学习率。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Placeholder:0\", shape=(?, 784), dtype=float32) Tensor(\"Placeholder_1:0\", shape=(?,), dtype=int64)\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "<tf.Variable 'Variable:0' shape=(784, 300) dtype=float32_ref> <tf.Variable 'Variable_1:0' shape=(300,) dtype=float32_ref>\n"
     ]
    }
   ],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784])\n",
    "y = tf.placeholder(\"int64\", [None])\n",
    "\n",
    "print(x, y)\n",
    "\n",
    "learning_rate = tf.placeholder(\"float\")\n",
    "\n",
    "def initialize(shape, stddev=0.1):\n",
    "  return tf.truncated_normal(shape, stddev=0.1) # 产生截断正态分布随机数，取值范围为 [ mean - 2 * stddev, mean + 2 * stddev ]\n",
    "\n",
    "L1_units_count = 300\n",
    "\n",
    "W_1 = tf.Variable(initialize([784, L1_units_count], stddev=0.05))\n",
    "b_1 = tf.Variable(initialize([L1_units_count]))\n",
    "print(W_1, b_1)  # W_1 [784, 100], 输出到第一个隐层，第一个隐层神经元 100 个\n",
    "\n",
    "logits_1 = tf.matmul(x, W_1) + b_1\n",
    "output_1 = tf.nn.relu(logits_1) # 第一个隐层激活函数采用relu\n",
    "\n",
    "L2_units_count = 10 \n",
    "W_2 = tf.Variable(initialize([L1_units_count, L2_units_count], stddev=0.063))\n",
    "b_2 = tf.Variable(initialize([L2_units_count]))\n",
    "logits_2 = tf.matmul(output_1, W_2) + b_2  # 第一个隐层的relu输出到输出层，输出神经元10个\n",
    "\n",
    "logits = logits_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits, 这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为可以根据需要设定。\n",
    "\n",
    "试试看，增大减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "softmax:\n",
    "    把我们定义的线性函数的输出转换成我们想要的格式，也就是关于10个数字类的概率分布。\n",
    "    因此，给定一张图片，它对于每一个数字的吻合度可以被softmax函数转换成为一个概率值\n",
    "'''\n",
    "\n",
    "'''\n",
    "交叉熵:\n",
    "    我们通常定义指标来表示一个模型是坏的，这个指标称为成本（cost）或损失（loss），然后尽量最小化这个指标\n",
    "    交叉熵是用来衡量我们的预测用于描述真相的低效性\n",
    "'''\n",
    "\n",
    "'''\n",
    "tf.reduce_mean: \n",
    "    函数用于计算张量tensor沿着指定的数轴（tensor的某一维度）上的的平均值，主要用作降维或者计算tensor（图像）的平均值。\n",
    "    计算张量的所有元素的总和\n",
    "    注意，这里的交叉熵不仅仅用来衡量单一的一对预测和真实值，而是所有100幅图片的交叉熵的总和。\n",
    "    对于100个数据点的预测表现比单一数据点的表现能更好地描述我们的模型的性能。\n",
    "'''\n",
    "\n",
    "'''\n",
    "GradientDescentOptimizer:\n",
    "    因为TensorFlow拥有一张描述你各个计算单元的图，\n",
    "    它可以自动地使用反向传播算法(backpropagation algorithm)来有效地确定你的变量是如何影响你想要最小化的那个成本值的。\n",
    "    然后，TensorFlow会用你选择的优化算法来不断地修改变量以降低成本。\n",
    "    TensorFlow用梯度下降算法（gradient descent algorithm）以learning_rate的学习速率最小化交叉熵。\n",
    "'''\n",
    "\n",
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "l2_loss = tf.nn.l2_loss(W_1)+tf.nn.l2_loss(W_2)\n",
    "total_loss = cross_entropy_loss + 7e-5*l2_loss\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=learning_rate).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布， 要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "tf.argmax 是一个非常有用的函数，它能给出某个tensor对象在某一维上的其数据最大值所在的索引值。\n",
    "由于标签向量是由0,1组成，因此最大值1所在的索引位置就是类别标签，比如tf.argmax(y,1)返回的是模型对于任一输入x预测到的标签值，\n",
    "而 tf.argmax(y_,1) 代表正确的标签，我们可以用 tf.equal 来检测我们的预测是否真实标签匹配(索引位置一样表示匹配)。\n",
    "'''\n",
    "\n",
    "pred = tf.nn.softmax(logits)\n",
    "\n",
    "'''\n",
    "这行代码会给我们一组布尔值。为了确定正确预测项的比例，我们可以把布尔值转换成浮点数，然后取平均值。\n",
    "例如，[True, False, True, True] 会变成 [1,0,1,1] ，取平均值后得到 0.75.\n",
    "\n",
    "用于测试数据集上面的正确率。\n",
    "'''\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), y)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# saver用于保存或恢复训练的模型。\n",
    "batch_size = 128\n",
    "trainig_step = 128*50\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.29086, the validation accuracy is 0.9164\n",
      "after 200 training steps, the loss is 0.140598, the validation accuracy is 0.9482\n",
      "after 300 training steps, the loss is 0.197435, the validation accuracy is 0.9562\n",
      "after 400 training steps, the loss is 0.239077, the validation accuracy is 0.9612\n",
      "after 500 training steps, the loss is 0.0742898, the validation accuracy is 0.968\n",
      "after 600 training steps, the loss is 0.0791225, the validation accuracy is 0.966\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/training/saver.py:966: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "after 700 training steps, the loss is 0.0971912, the validation accuracy is 0.9656\n",
      "after 800 training steps, the loss is 0.0791593, the validation accuracy is 0.9704\n",
      "after 900 training steps, the loss is 0.0227928, the validation accuracy is 0.9726\n",
      "after 1000 training steps, the loss is 0.0692111, the validation accuracy is 0.9746\n",
      "after 1100 training steps, the loss is 0.0676078, the validation accuracy is 0.975\n",
      "after 1200 training steps, the loss is 0.0672191, the validation accuracy is 0.9742\n",
      "after 1300 training steps, the loss is 0.0140895, the validation accuracy is 0.9776\n",
      "after 1400 training steps, the loss is 0.0772072, the validation accuracy is 0.9752\n",
      "after 1500 training steps, the loss is 0.0528289, the validation accuracy is 0.9758\n",
      "after 1600 training steps, the loss is 0.0513614, the validation accuracy is 0.979\n",
      "after 1700 training steps, the loss is 0.029635, the validation accuracy is 0.9768\n",
      "after 1800 training steps, the loss is 0.0376764, the validation accuracy is 0.9764\n",
      "after 1900 training steps, the loss is 0.104012, the validation accuracy is 0.9754\n",
      "after 2000 training steps, the loss is 0.0271648, the validation accuracy is 0.977\n",
      "after 2100 training steps, the loss is 0.0463342, the validation accuracy is 0.9786\n",
      "after 2200 training steps, the loss is 0.0142948, the validation accuracy is 0.9786\n",
      "after 2300 training steps, the loss is 0.0314175, the validation accuracy is 0.9792\n",
      "after 2400 training steps, the loss is 0.105574, the validation accuracy is 0.9776\n",
      "after 2500 training steps, the loss is 0.0261653, the validation accuracy is 0.9786\n",
      "after 2600 training steps, the loss is 0.0230702, the validation accuracy is 0.9792\n",
      "after 2700 training steps, the loss is 0.019855, the validation accuracy is 0.9798\n",
      "after 2800 training steps, the loss is 0.0439655, the validation accuracy is 0.9806\n",
      "after 2900 training steps, the loss is 0.0667303, the validation accuracy is 0.978\n",
      "after 3000 training steps, the loss is 0.0227116, the validation accuracy is 0.9798\n",
      "after 3100 training steps, the loss is 0.0170728, the validation accuracy is 0.9788\n",
      "after 3200 training steps, the loss is 0.0226339, the validation accuracy is 0.981\n",
      "after 3300 training steps, the loss is 0.0302204, the validation accuracy is 0.9798\n",
      "after 3400 training steps, the loss is 0.0194663, the validation accuracy is 0.981\n",
      "after 3500 training steps, the loss is 0.00721218, the validation accuracy is 0.9822\n",
      "after 3600 training steps, the loss is 0.0101445, the validation accuracy is 0.9828\n",
      "after 3700 training steps, the loss is 0.0114939, the validation accuracy is 0.9792\n",
      "after 3800 training steps, the loss is 0.0125806, the validation accuracy is 0.9802\n",
      "after 3900 training steps, the loss is 0.00593683, the validation accuracy is 0.9824\n",
      "after 4000 training steps, the loss is 0.0185647, the validation accuracy is 0.9802\n",
      "after 4100 training steps, the loss is 0.00609922, the validation accuracy is 0.982\n",
      "after 4200 training steps, the loss is 0.0121922, the validation accuracy is 0.9796\n",
      "after 4300 training steps, the loss is 0.00524139, the validation accuracy is 0.9826\n",
      "after 4400 training steps, the loss is 0.0338322, the validation accuracy is 0.9778\n",
      "after 4500 training steps, the loss is 0.0081172, the validation accuracy is 0.9824\n",
      "after 4600 training steps, the loss is 0.0211128, the validation accuracy is 0.9814\n",
      "after 4700 training steps, the loss is 0.0084483, the validation accuracy is 0.9824\n",
      "after 4800 training steps, the loss is 0.00355838, the validation accuracy is 0.9842\n",
      "after 4900 training steps, the loss is 0.0055415, the validation accuracy is 0.9822\n",
      "after 5000 training steps, the loss is 0.00930421, the validation accuracy is 0.9802\n",
      "after 5100 training steps, the loss is 0.0157987, the validation accuracy is 0.9792\n",
      "after 5200 training steps, the loss is 0.00409949, the validation accuracy is 0.982\n",
      "after 5300 training steps, the loss is 0.00896085, the validation accuracy is 0.981\n",
      "after 5400 training steps, the loss is 0.0172658, the validation accuracy is 0.9836\n",
      "after 5500 training steps, the loss is 0.00524338, the validation accuracy is 0.9822\n",
      "after 5600 training steps, the loss is 0.00172103, the validation accuracy is 0.984\n",
      "after 5700 training steps, the loss is 0.00463185, the validation accuracy is 0.9822\n",
      "after 5800 training steps, the loss is 0.0100027, the validation accuracy is 0.984\n",
      "after 5900 training steps, the loss is 0.00481554, the validation accuracy is 0.982\n",
      "after 6000 training steps, the loss is 0.0090678, the validation accuracy is 0.982\n",
      "after 6100 training steps, the loss is 0.00819538, the validation accuracy is 0.9832\n",
      "after 6200 training steps, the loss is 0.00651985, the validation accuracy is 0.9824\n",
      "after 6300 training steps, the loss is 0.00487005, the validation accuracy is 0.984\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9824\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "    使用一小部分的随机数据来进行训练被称为随机训练（stochastic training）- 在这里更确切的说是随机梯度下降训练。\n",
    "    在理想情况下，我们希望用我们所有的数据来进行每一步的训练，因为这能给我们更好的训练结果，但显然这需要很大的计算开销。\n",
    "    所以，每一次训练我们可以使用不同的数据子集，这样做既可以减少计算开销，又可以最大化地学习到数据集的总体特性。\n",
    "    这里使用32个作为子集\n",
    "'''\n",
    "lr = 0.9\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        '''\n",
    "        if trainig_step<1800:\n",
    "            lr = 1.2\n",
    "        elif trainig_step<3400:\n",
    "            lr = 0.3\n",
    "        else:\n",
    "            lr = 0.01\n",
    "        '''\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss = sess.run(\n",
    "            [optimizer, cross_entropy_loss],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                learning_rate: lr\n",
    "            })\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面，用我们训练的模型做一个测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-6300\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "我们计算所学习到的模型在测试数据集上面的正确率。\n",
    "'''\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16]\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(mnist.test.labels[idx],\n",
    "                                                  order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
